﻿using System;
using System.Collections.Generic;
using System.Text;
using BussinessLogicTecnoPez.Tipos_Comunes;
using System.Collections;

namespace BussinessLogicTecnoPez.Produccion.Compras.MatrizHomogeneizacion
{
    public class OfertaAnalizada: IComparable
    {
        #region "Atributos"
        private int idOferta;
        private Proveedor objProveedor;
        private DateTime fechaCarga;
        private DateTime fechaVencimiento;
        private TipoMoneda objTipoMoneda;
        private decimal monto;

        private List<FactorAnalizado> objFactores;        
        #endregion

        #region "Properties"
        public int IdOferta
        {
            get { return idOferta; }
            set { idOferta = value; }
        }

        public Proveedor Proveedor
        {
            get { return objProveedor; }
            set { objProveedor = value; }
        }

        public DateTime FechaCarga
        {
            get { return fechaCarga; }
            set { fechaCarga = value; }
        }

        public DateTime FechaVencimiento
        {
            get { return fechaVencimiento; }
            set { fechaVencimiento = value; }
        }

        public string FechaVencimientoString
        {
            get { return fechaVencimiento.ToShortDateString(); }
        }

        public TipoMoneda TipoMoneda
        {
            get { return objTipoMoneda; }
            set { objTipoMoneda = value; }
        }

        public decimal Monto
        {
            get { return monto; }
            set { monto = value; }
        }

        /// <summary>
        /// Suma el puntaje de cada factor para calcular el total
        /// </summary>
        public decimal Total
        {
            get
            {
                if (this.objFactores != null && this.objFactores.Count > 0)
                {
                    decimal decTotal = 0;
                    foreach (FactorAnalizado objFactor in this.objFactores)
                    {
                        decTotal += objFactor.Puntaje;
                    }
                    return decTotal;
                }
                else
                {
                    return 0;
                }
            }
        }

        public List<FactorAnalizado> Factores
        {
            get { return objFactores; }
        }
        #endregion

        #region "Contructor"
        public OfertaAnalizada(OfertaProveedor objOferta, List<FactorAnalizado> objFactoresAnalizados, int idInsumo)
        {
            this.FechaCarga = objOferta.FechaCarga;
            this.FechaVencimiento = objOferta.FechaVencimiento;
            this.IdOferta = objOferta.IdOferta;
            this.Monto = objOferta.Monto;
            this.Proveedor = objOferta.Proveedor;
            this.TipoMoneda = objOferta.TipoMoneda;
            this.objFactores = this.CreateFactors(objFactoresAnalizados, objOferta.FactoresOfertaProveedor.ItemList, objOferta.DetalleOfertaProveedor, idInsumo);
        }
        private List<FactorAnalizado> CreateFactors(List<FactorAnalizado> objFactoresAnalizados, ArrayList objFactoresOferta, DetalleOfertaProveedor objDetalleOferta, int idInsumo)
        {
            if (objFactoresAnalizados == null || objFactoresAnalizados.Count == 0)
                return null;

            List<FactorAnalizado> objFactores = new List<FactorAnalizado>();
            FactorAnalizado objFactor;

            foreach (FactorAnalizado objAnalizado in objFactoresAnalizados)
            {
                objFactor = new FactorAnalizado(new Factor(objAnalizado.IdFactor, objAnalizado.Descripcion, objAnalizado.Maximizante));
                if (objAnalizado.IdFactor == -1)
                    objFactor.Valor = this.GetValueFactor(-1, idInsumo, objDetalleOferta);
                else if (objAnalizado.IdFactor == -2)
                    objFactor.Valor = this.GetValueFactor(-2, idInsumo, objDetalleOferta);
                else
                    objFactor.Valor = this.GetValueFactor(objFactor.IdFactor, objFactoresOferta);

                objFactores.Add(objFactor);
            }
            return objFactores;
        }
        private decimal GetValueFactor(int idFactor, ArrayList objFactoresOferta)
        {
            foreach (FactorOfertaProveedor objFactor in objFactoresOferta)
            {
                if (objFactor.IdFactor == idFactor)
                {
                    return objFactor.Valor;
                }
            }
            return 0;
        }
        private decimal GetValueFactor(int idFactor, int idInsumo, DetalleOfertaProveedor objDetalleOferta)
        {
            foreach (ItemDetalleOfertaProveedor objItem in objDetalleOferta)
            {
                if (objItem.IdInsumo == idInsumo)
                {
                    if (idFactor == -1)
                        return objItem.Precio;
                    else
                        return objItem.Cantidad;
                }
            }
            return 0;
        }
        #endregion

        #region "Metodos"
        public FactorAnalizado GetFactorCantidad()
        {
            foreach (FactorAnalizado objFactor in this.objFactores)
            {
                if (objFactor.IdFactor == -2)
                {
                    return objFactor;
                }
            }
            return null;
        }
        #endregion

        #region Miembros de IComparable

        public int CompareTo(object obj)
        {
            OfertaAnalizada objOferta = obj as OfertaAnalizada;
            return Convert.ToInt32(Math.Round(objOferta.Total - this.Total, 0));
            //throw new Exception("The method or operation is not implemented.");
        }

        #endregion
    }
}
